THESIS FOR THE DEGREE OF LICENTIATE OF ENGINEERING Schemes to Improve the Efficiency of Hardware Transactional Memory Systems

In today’s ubiquitous multiprocessor environment parallel programming becomes an important tool to reap the maximum gain. But the traditional lock-based parallel programming model is not attracting average programmers as the level of expertise needed is very high. A program can be trapped in deadlock and livelock by unconscious locking of shared resources. Furthermore, a lock-based parallel programming model uses blocking synchronization where execution of a critical section is exclusive. A processor that executes in a critical section blocks all other processor to execute inside the critical section. The blocking nature can limit concurrency if two processors follow two different execution paths yet in the critical section; in that case there will be no data race. Recently, many researchers proposed transactional memory that promises to simplify parallel programming as well as to offer non-blocking synchronization. In transactional memory systems, critical sections are executed in transactions where multiple transactions from different threads can be executed speculatively in parallel. Data integrity, hence the program correctness is maintained by isolating the speculative execution and committing atomically at the end. A commit can force other ongoing transactions to be squashed if a data conflict is detected. Depending on the mechanism in which the isolation, atomic commit and conflict detection is performed, transactional memory systems could be broadly categorized as software transactional memory (STM) and hardware transactional memory (HTM). In this thesis, three problems of HTM systems that hurt the execution time are discovered and novel solutions to the problems are proposed. In an HTM system that detects conflicts lazily, transactions from one thread can repeatedly squash a transaction from another thread which can lead to a starvation problem for the latter. A novel solution that uses squash counts for individual transaction is proposed to avoid starvation. At a data conflict, HTM systems squash the speculative executions and re-execute the transactions from the beginning. Re-execution from the beginning may waste a part of execution that is correct and hurt performance. A scheme is proposed that smartly takes intermediate checkpoints so that the correct execution can be saved from a squashing transaction. To isolate the speculative execution, a private buffer is used to store the speculative data. The drastic effect of speculative buffer overflow is discovered and a scheme is proposed that effectively uses the speculative buffer to reduce overflows.